package com.hksj.ecm.service;

import com.hksj.common.core.common.SpecialityModelCodeEnum;
import com.hksj.ecm.dto.EnergyStatisticsDTO;
import com.hksj.ecm.mapper.EnergyStatisticalAnalysisMapper;
import com.hksj.ecm.vo.*;
import com.hksj.tdengine.taos.service.TaosService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.util.CollectionUtils;

import java.text.DecimalFormat;
import java.util.*;
import java.util.function.BiConsumer;
import java.util.stream.Collectors;

/**
 * @ClassName EnergyStatisticalAnalysisService
 * @Description TODO
 * @Author @陈章
 * @Date 2024/8/16 14:19
 * @Version 1.0
 */
@Service
public class EnergyStatisticalAnalysisService {

    @Autowired
    private EnergyStatisticalAnalysisMapper mapper;
    @Autowired
    private TaosService taosService;

    public EnergyGroupingVO queryEnergyStatisticalAnalysis(EnergyStatisticsDTO dto) {
        dto.setCode(SpecialityModelCodeEnum.energy_consumption.getCode());
        //根据模型id集合查询所有符合条件的设备
        List<EnergyStatisticsVO> list = mapper.selectDeviceBySpaceModelIdList(dto);
        EnergyGroupingVO energyGroupingVO = new EnergyGroupingVO();
        energyGroupingVO.setNames(dto.getStatisticNameList());
        List<String> consumptionValues=new ArrayList<>();
        //保证设备集合不为空
        if (!CollectionUtils.isEmpty(list)) {
            // 将数据按 productId 产品分组，并收集每个 productId 下的所有 EnergyStatisticsVO
            Map<String, List<EnergyStatisticsVO>> groupedByProductId = list.stream()
                    .collect(Collectors.groupingBy(EnergyStatisticsVO::getProductId));
            // 将分组结果转换为 List<Map<productId, List<EnergyStatisticsVO>>>
            groupedByProductId.forEach(new BiConsumer<String, List<EnergyStatisticsVO>>() {
                @Override
                public void accept(String key, List<EnergyStatisticsVO> energyStatisticsVO) {
                    //拼接查询的超级表名称:"properties_" + productId
                    String tableName = "properties_".concat(key);
                    //检查超级表是否存在
                    Boolean existStale = taosService.checkStable("jetlinks_clean_room", tableName);
                    if (existStale) {
                        //根据产品id查询产品下所有的设备能耗情况
                        List<EnergyVO> vos = mapper.queryEnergyStatisticalAnalysis(dto, tableName);
                        //将产品下查询的所有设备能耗匹配设置到产品分组设备列表中
                        energyStatisticsVO.forEach(energyTrendDeviceVO -> {
                            vos.forEach(deviceEnergy -> {
                                if (Objects.equals(energyTrendDeviceVO.getDeviceId(), deviceEnergy.getDeviceId())) {
                                    energyTrendDeviceVO.setConsumptionValue(deviceEnergy.getConsumptionValue());
                                }
                            });
                        });
                    }
                }
            });
            // 合并产品分组下所有设备值列表
            List<EnergyStatisticsVO> allValues = groupedByProductId.values().stream()
                    .flatMap(List::stream)
                    .collect(Collectors.toList());

            //根据楼栋分组统计方式
            if (dto.getStatisticType() == 1) {
                //分组楼层id
                List<Long> ids = dto.getIds();
                for (Long id : ids) {
                    // 使用Stream API求和，并处理null和0.0的情况
                    double sum = allValues.stream()
                            .filter(vo -> vo.getBuildingId().equals(String.valueOf(id))) // 筛选出buildingId等于id的元素
                            .mapToDouble(vo -> {
                                String value = vo.getConsumptionValue();
                                if (value == null) {
                                    return 0.0; // 处理null值
                                } else {
                                    try {
                                        return Double.parseDouble(value); // 正常转换
                                    } catch (NumberFormatException e) {
                                        return 0.0; // 无效的字符串，默认为0.0
                                    }
                                }
                            })
                            .sum(); // 求和

                    // 格式化结果以保留两位小数
                    DecimalFormat df = new DecimalFormat("0.00");
                    String formattedSum = df.format(sum);
                    consumptionValues.add(formattedSum);
                }
                energyGroupingVO.setConsumptionValues(consumptionValues);
            }
            //根据楼层分组统计方式
            if (dto.getStatisticType() == 2) {
                //分组楼层id
                List<Long> ids = dto.getIds();
                for (Long id : ids) {
                    // 使用Stream API求和，并处理null和0.0的情况
                    double sum = allValues.stream()
                            .filter(vo -> vo.getFloorId().equals(String.valueOf(id))) // 筛选出buildingId等于id的元素
                            .mapToDouble(vo -> {
                                String value = vo.getConsumptionValue();
                                if (value == null) {
                                    return 0.0; // 处理null值
                                } else {
                                    try {
                                        return Double.parseDouble(value); // 正常转换
                                    } catch (NumberFormatException e) {
                                        return 0.0; // 无效的字符串，默认为0.0
                                    }
                                }
                            })
                            .sum(); // 求和

                    // 格式化结果以保留两位小数
                    DecimalFormat df = new DecimalFormat("0.00");
                    String formattedSum = df.format(sum);
                    consumptionValues.add(formattedSum);
                }
                energyGroupingVO.setConsumptionValues(consumptionValues);
            }
            //根据科室统计方式
            if (dto.getStatisticType() == 3) {
                //分组楼层id
                List<String> ids = dto.getDepartmentValueList();
                for (String id : ids) {
                    // 使用Stream API求和，并处理null和0.0的情况
                    double sum = allValues.stream()
                            .filter(vo -> vo.getFloorId().equals(id)) // 筛选出buildingId等于id的元素
                            .mapToDouble(vo -> {
                                String value = vo.getConsumptionValue();
                                if (value == null) {
                                    return 0.0; // 处理null值
                                } else {
                                    try {
                                        return Double.parseDouble(value); // 正常转换
                                    } catch (NumberFormatException e) {
                                        return 0.0; // 无效的字符串，默认为0.0
                                    }
                                }
                            })
                            .sum(); // 求和

                    // 格式化结果以保留两位小数
                    DecimalFormat df = new DecimalFormat("0.00");
                    String formattedSum = df.format(sum);
                    consumptionValues.add(formattedSum);
                }
                energyGroupingVO.setConsumptionValues(consumptionValues);
            }
        }
        return energyGroupingVO;
    }
}
